home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / swtools / mipsABI / examples / sup / supcmeat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  39.6 KB  |  1,522 lines
  1. /*
  2.  * Copyright (c) 1992 Carnegie Mellon University
  3.  * All Rights Reserved.
  4.  * 
  5.  * Permission to use, copy, modify and distribute this software and its
  6.  * documentation is hereby granted, provided that both the copyright
  7.  * notice and this permission notice appear in all copies of the
  8.  * software, derivative works or modified versions, and any portions
  9.  * thereof, and that both notices appear in supporting documentation.
  10.  *
  11.  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  12.  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  13.  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  14.  *
  15.  * Carnegie Mellon requests users of this software to return to
  16.  *
  17.  *  Software Distribution Coordinator  or  Software_Distribution@CS.CMU.EDU
  18.  *  School of Computer Science
  19.  *  Carnegie Mellon University
  20.  *  Pittsburgh PA 15213-3890
  21.  *
  22.  * any improvements or extensions that they make and grant Carnegie Mellon
  23.  * the rights to redistribute these changes.
  24.  */
  25. /*
  26.  * sup "meat" routines
  27.  **********************************************************************
  28.  * HISTORY
  29.  *
  30.  * 7-July-93  Nate Williams at Montana State University
  31.  *    Modified SUP to use gzip based compression when sending files
  32.  *    across the network to save BandWidth
  33.  *
  34.  * $Log: supcmeat.c,v $
  35.  * Revision 1.3  1993/08/04  17:46:18  brezak
  36.  * Changes from nate for gzip'ed sup
  37.  *
  38.  * Revision 1.2  1993/05/24  18:57:50  brezak
  39.  * Use /var/tmp for NetBSD
  40.  *
  41.  * Revision 1.1.1.1  1993/05/21  14:52:18  cgd
  42.  * initial import of CMU's SUP to NetBSD
  43.  *
  44.  * Revision 1.16  92/09/09  22:04:51  mrt
  45.  *     Really added bww's recvone changes this time. 
  46.  *     Added code to support non-crypting version of sup.
  47.  *     [92/09/01            mrt]
  48.  * 
  49.  * Revision 1.15  92/08/11  12:07:09  mrt
  50.  *     Added support to add release to FILEWHEN name.
  51.  *     Updated variable arguemnt list usage - bww
  52.  *     Updated recvone() to take a va_list - bww
  53.  *     Changed conditional for rpausing code from CMUCS to MACH
  54.  *     [92/07/24            mrt]
  55.  * 
  56.  * Revision 1.14  92/02/08  18:24:12  mja
  57.  *     Only apply "keep" mode when local file is strictly newer
  58.  *     otherwise allow update as before if necessary.
  59.  *     [92/02/08  18:09:00  mja]
  60.  * 
  61.  *     Added support for -k (keep) option to needone().  Rewrote and
  62.  *     commented other parts of needone().
  63.  *     [92/01/17            vdelvecc]
  64.  * 
  65.  * Revision 1.13  91/05/16  14:49:41  ern
  66.  *     Add timestap to fileserver.
  67.  *     Drop day of the week from 5 messages.
  68.  *     [91/05/16  14:47:53  ern]
  69.  * 
  70.  * Revision 1.12  89/08/23  14:55:44  gm0w
  71.  *     Changed msgf routines to msg routines.
  72.  *     [89/08/23            gm0w]
  73.  * 
  74.  * Revision 1.11  89/08/03  19:49:10  mja
  75.  *     Updated to use v*printf() in place of _doprnt().
  76.  *     [89/04/19            mja]
  77.  * 
  78.  * Revision 1.10  89/06/18  14:41:27  gm0w
  79.  *     Fixed up some notify messages of errors to use "SUP:" prefix.
  80.  *     [89/06/18            gm0w]
  81.  * 
  82.  * Revision 1.9  89/06/10  15:12:17  gm0w
  83.  *     Changed to always use rename to install targets.  This breaks hard
  84.  *     links and recreates those known to sup, other links will be orphaned.
  85.  *     [89/06/10            gm0w]
  86.  * 
  87.  * Revision 1.8  89/05/24  15:04:23  gm0w
  88.  *     Added code to check for EINVAL from FSPARAM ioctl for disk
  89.  *     space check failures when the ioctl is not implemented.
  90.  *     [89/05/24            gm0w]
  91.  * 
  92.  * Revision 1.7  89/01/16  18:22:28  gm0w
  93.  *     Changed needone() to check that mode of files match before
  94.  *     setting update if times also match.
  95.  *     [89/01/16            gm0w]
  96.  * 
  97.  * 10-Feb-88  Glenn Marcy (gm0w) at Carnegie-Mellon University
  98.  *    Added timeout to backoff.
  99.  *
  100.  * 27-Dec-87  Glenn Marcy (gm0w) at Carnegie-Mellon University
  101.  *    Added crosspatch support.
  102.  *
  103.  * 09-Sep-87  Glenn Marcy (gm0w) at Carnegie-Mellon University
  104.  *    Added code to be less verbose when updating files that have
  105.  *    already been successfully upgraded.
  106.  *
  107.  * 28-Jun-87  Glenn Marcy (gm0w) at Carnegie-Mellon University
  108.  *    Added code for "release" support.
  109.  *
  110.  * 26-May-87  Doug Philips (dwp) at Carnegie-Mellon University
  111.  *    Converted to end connection with more information.
  112.  *    Added done routine.  Modified goaway routine to free old
  113.  *    goawayreason.
  114.  *
  115.  * 26-May-87  Doug Philips (dwp) at Carnegie-Mellon University
  116.  *    Use computeBackoff from scm instead of doing it ourselves.
  117.  *
  118.  * 25-May-87  Doug Philips (dwp) at Carnegie-Mellon University
  119.  *    Split off from sup.c and reindented goaway calls.
  120.  *
  121.  **********************************************************************
  122.  */
  123.  
  124. #include "supcdefs.h"
  125. #include <sys/wait.h>
  126. #if __STDC__
  127. #include <stdarg.h>
  128. #else
  129. #include <varargs.h>
  130. #endif
  131. #ifdef _ABI_SOURCE
  132. #include <utime.h>
  133. #endif
  134.  
  135. #if __STDC__
  136. void done (int, char *, ...);
  137. void goaway (char *, ...);
  138. #endif
  139.  
  140. TREE *lastT;                /* last filenames in collection */
  141. jmp_buf sjbuf;                /* jump location for network errors */
  142. int dontjump;                /* flag to void sjbuf */
  143. int cancompress=FALSE;            /* Can we do compression? */
  144. int docompress=FALSE;            /* Do we do compression? */
  145.  
  146. extern COLLECTION *thisC;        /* collection list pointer */
  147. extern int rpauseflag;            /* don't disable resource pausing */
  148. extern int portdebug;            /* network debugging ports */
  149.  
  150. /*************************************************
  151.  ***    U P G R A D E   C O L L E C T I O N    ***
  152.  *************************************************/
  153.  
  154. /* The next two routines define the fsm to support multiple fileservers
  155.  * per collection.
  156.  */
  157. getonehost (t,state)
  158. register TREE *t;
  159. int *state;
  160. {
  161.     if (t->Tflags != *state)
  162.         return (SCMOK);
  163.     if (*state != 0 && t->Tmode == SCMEOF) {
  164.         t->Tflags = 0;
  165.         return (SCMOK);
  166.     }
  167.     if (*state == 2)
  168.         t->Tflags--;
  169.     else
  170.         t->Tflags++;
  171.     thisC->Chost = t;
  172.     return (SCMEOF);
  173. }
  174.  
  175. TREE *getcollhost (tout,backoff,state,nhostsp)
  176. int *tout,*backoff,*state,*nhostsp;
  177. {
  178.     static int laststate = 0;
  179.     static int nhosts = 0;
  180.  
  181.     if (*state != laststate) {
  182.         *nhostsp = nhosts;
  183.         laststate = *state;
  184.         nhosts = 0;
  185.     }
  186.     if (Tprocess (thisC->Chtree,getonehost,*state) == SCMEOF) {
  187.         if (*state != 0 && nhosts == 0 && !dobackoff (tout,backoff))
  188.             return (NULL);
  189.         nhosts++;
  190.         return (thisC->Chost);
  191.     }
  192.     if (nhosts == 0)
  193.         return (NULL);
  194.     if (*state == 2)
  195.         (*state)--;
  196.     else
  197.         (*state)++;
  198.     return (getcollhost (tout,backoff,state,nhostsp));
  199. }
  200.  
  201. /*  Upgrade a collection from the file server on the appropriate
  202.  *  host machine.
  203.  */
  204.  
  205. getcoll ()
  206. {
  207.     register TREE *t;
  208.     register int x;
  209.     int tout,backoff,state,nhosts;
  210.  
  211.     collname = thisC->Cname;
  212.     tout = thisC->Ctimeout;
  213.     lastT = NULL;
  214.     backoff = 2;
  215.     state = 0;
  216.     nhosts = 0;
  217.     for (;;) {
  218.         t = getcollhost (&tout,&backoff,&state,&nhosts);
  219.         if (t == NULL) {
  220.             finishup (SCMEOF);
  221.             notify ((char *)NULL);
  222.             return;
  223.         }
  224.         t->Tmode = SCMEOF;
  225.         dontjump = FALSE;
  226.         if (!setjmp (sjbuf) && !signon (t,nhosts,&tout) && !setup (t))
  227.             break;
  228.         (void) requestend ();
  229.     }
  230.     dontjump = FALSE;
  231.     if (setjmp (sjbuf))
  232.         x = SCMERR;
  233.     else {
  234.         login ();
  235.         listfiles ();
  236.         recvfiles ();
  237.         x = SCMOK;
  238.     }
  239.     if (thisC->Clockfd >= 0) {
  240.         (void) close (thisC->Clockfd);
  241.         thisC->Clockfd = -1;
  242.     }
  243.     finishup (x);
  244.     notify ((char *)NULL);
  245. }
  246.  
  247. /***  Sign on to file server ***/
  248.  
  249. int signon (t,nhosts,tout)
  250. register TREE *t;
  251. int nhosts;
  252. int *tout;
  253. {
  254.     register int x;
  255.     int timeout;
  256.     long tloc;
  257.  
  258.     if ((thisC->Cflags&CFLOCAL) == 0 && thishost (thisC->Chost->Tname)) {
  259.         vnotify ("SUP: Skipping local collection %s\n",collname);
  260.         t->Tmode = SCMEOF;
  261.         return (TRUE);
  262.     }
  263.     if (nhosts == 1)
  264.         timeout = *tout;
  265.     else
  266.         timeout = 0;
  267.     x = request (portdebug?DEBUGFPORT:FILEPORT,
  268.             thisC->Chost->Tname,&timeout);
  269.     if (nhosts == 1)
  270.         *tout = timeout;
  271.     if (x != SCMOK) {
  272.         if (nhosts) {
  273.             notify ("SUP: Can't connect to host %s\n",
  274.                 thisC->Chost->Tname);
  275.             t->Tmode = SCMEOF;
  276.         } else
  277.             t->Tmode = SCMOK;
  278.         return (TRUE);
  279.     }
  280.     xpatch = FALSE;
  281.     x = msgsignon ();    /* signon to fileserver */
  282.     if (x != SCMOK)
  283.         goaway ("Error sending signon request to fileserver");
  284.     x = msgsignonack ();    /* receive signon ack from fileserver */
  285.     if (x != SCMOK)
  286.         goaway ("Error reading signon reply from fileserver");
  287.     tloc = time ((long *)NULL);
  288.     vnotify ("SUP Fileserver %d.%d (%s) %d on %s at %.8s\n",
  289.         protver,pgmver,scmver,fspid,remotehost(),ctime (&tloc) + 11);
  290.     free (scmver);
  291.     scmver = NULL;
  292.     if (protver < 4) {
  293.         dontjump = TRUE;
  294.         goaway ("Fileserver sup protocol version is obsolete.");
  295.         notify ("SUP: This version of sup can only communicate with a fileserver using at least\n");
  296.         notify ("SUP: version 4 of the sup network protocol.  You should either run a newer\n");
  297.         notify ("SUP: version of the sup fileserver or find an older version of sup.\n");
  298.         t->Tmode = SCMEOF;
  299.         return (TRUE);
  300.     }
  301.     /* If protocol is > 7 then try compression */
  302.     if (protver > 7) {
  303.         cancompress = TRUE;
  304.     }
  305.     return (FALSE);
  306. }
  307.  
  308. /***  Tell file server what to connect to ***/
  309.  
  310. setup (t)
  311. register TREE *t;
  312. {
  313.     char buf[STRINGLENGTH];
  314.     char relsufix[STRINGLENGTH];
  315.     register int f,x;
  316.     struct stat sbuf;
  317.  
  318.     if (chdir (thisC->Cbase) < 0)
  319.         goaway ("Can't change to base directory %s",thisC->Cbase);
  320.     if (stat ("sup",&sbuf) < 0) {
  321.         (void) mkdir ("sup",0755);
  322.         if (stat("sup",&sbuf) < 0)
  323.             goaway ("Can't create directory %s/sup",thisC->Cbase);
  324.         vnotify ("SUP Created directory %s/sup\n",thisC->Cbase);
  325.     }
  326.     if (thisC->Cprefix && chdir (thisC->Cprefix) < 0)
  327.         goaway ("Can't change to %s from base directory %s",
  328.             thisC->Cprefix,thisC->Cbase);
  329.     if (stat (".",&sbuf) < 0)
  330.         goaway ("Can't stat %s directory %s",
  331.             thisC->Cprefix?"prefix":"base",
  332.             thisC->Cprefix?thisC->Cprefix:thisC->Cbase);
  333.     if (thisC->Cprefix)  (void) chdir (thisC->Cbase);
  334.     /* read time of last upgrade from when file */
  335.  
  336.     if ((thisC->Cflags&CFURELSUF) && thisC->Crelease)
  337.         (void) sprintf (relsufix,".%s",thisC->Crelease);
  338.     else
  339.         relsufix[0] = '\0';
  340.     (void) sprintf (buf,FILEWHEN,collname,relsufix);
  341.     f = open (buf,O_RDONLY,0);
  342.     if (f >= 0) {
  343.         if (read(f,(char *)&lasttime,sizeof(long)) != sizeof(long))
  344.             lasttime = 0;
  345.         (void) close (f);
  346.     } else
  347.         lasttime = 0;
  348.     /* setup for msgsetup */
  349.     basedir = thisC->Chbase;
  350.     basedev = sbuf.st_dev;
  351.     baseino = sbuf.st_ino;
  352.     listonly = (thisC->Cflags&CFLIST);
  353.     newonly = ((thisC->Cflags&(CFALL|CFDELETE|CFOLD)) == 0);
  354.     release = thisC->Crelease;
  355.     x = msgsetup ();
  356.     if (x != SCMOK)
  357.         goaway ("Error sending setup request to file server");
  358.     x = msgsetupack ();
  359.     if (x != SCMOK)
  360.         goaway ("Error reading setup reply from file server");
  361.     if (setupack == FSETUPOK) {
  362.         /* Test encryption */
  363.         if (netcrypt (thisC->Ccrypt) != SCMOK)
  364.             goaway ("Running non-crypting sup");
  365.         crypttest = CRYPTTEST;
  366.         x = msgcrypt ();
  367.         if (x != SCMOK)
  368.             goaway ("Error sending encryption test request");
  369.         x = msgcryptok ();
  370.         if (x == SCMEOF)
  371.             goaway ("Data encryption test failed");
  372.         if (x != SCMOK)
  373.             goaway ("Error reading encryption test reply");
  374.         return (FALSE);
  375.     }
  376.     switch (setupack) {
  377.     case FSETUPSAME:
  378.         notify ("SUP: Attempt to upgrade from same host to same directory\n");
  379.         done (FDONESRVERROR,"Overwrite error");
  380.     case FSETUPHOST:
  381.         notify ("SUP: This host has no permission to access %s\n",
  382.             collname);
  383.         done (FDONESRVERROR,"Permission denied");
  384.     case FSETUPOLD:
  385.         notify ("SUP: This version of SUP is too old for the fileserver\n");
  386.         done (FDONESRVERROR,"Obsolete client");
  387.     case FSETUPRELEASE:
  388.         notify ("SUP: Invalid release %s for collection %s\n",
  389.             release == NULL ? DEFRELEASE : release,collname);
  390.         done (FDONESRVERROR,"Invalid release");
  391.     case FSETUPBUSY:
  392.         vnotify ("SUP Fileserver is currently busy\n");
  393.         t->Tmode = SCMOK;
  394.         doneack = FDONESRVERROR;
  395.         donereason = "Fileserver is busy";
  396.         (void) netcrypt ((char *)NULL);
  397.         (void) msgdone ();
  398.         return (TRUE);
  399.     default:
  400.         goaway ("Unrecognized file server setup status %d",setupack);
  401.     }
  402.     /* NOTREACHED */
  403. }
  404.  
  405. /***  Tell file server what account to use ***/
  406.  
  407. int login ()
  408. {
  409.     char buf[STRINGLENGTH];
  410.     register int f,x;
  411. #ifdef _ABI_SOURCE
  412.     struct flock lock;
  413. #endif
  414.  
  415.     /* lock collection if desired */
  416.     (void) sprintf (buf,FILELOCK,collname);
  417. #ifdef _ABI_SOURCE
  418.     f = open (buf,O_RDWR,0);    /* use write lock for exclusive */
  419. #else
  420.     f = open (buf,O_RDONLY,0);
  421. #endif
  422.     if (f >= 0) {
  423. #ifdef _ABI_SOURCE
  424.         /* lock setup: read lock for whole file */
  425.         lock.l_type = F_WRLCK;
  426.         lock.l_start = 0;
  427.         lock.l_whence = 0;
  428.         lock.l_len = 0;
  429.         if (fcntl (x, F_SETLK, &lock) < 0) {
  430.             if (errno != EACCES)
  431.                 goaway ("Can't lock collection %s",collname);
  432.             lock.l_type = F_RDLCK;
  433.             if (fcntl (x, F_SETLK, &lock) < 0) {
  434.                 (void) close (f);
  435.                 if (errno == EACCES)
  436.                     goaway ("Collection %s is locked by another sup",collname);
  437.                 goaway ("Can't lock collection %s",collname);
  438.             }
  439.             vnotify ("SUP Waiting for exclusive access lock\n");
  440.             lock.l_type = F_WRLCK;
  441.             if (fcntl (x, F_SETLKW, &lock) < 0) {
  442.                 (void) close (f);
  443.                 goaway ("Can't lock collection %s",collname);
  444.             }
  445.         }
  446. #else
  447.         if (flock (f,(LOCK_EX|LOCK_NB)) < 0) {
  448.             if (errno != EWOULDBLOCK)
  449.                 goaway ("Can't lock collection %s",collname);
  450.             if (flock (f,(LOCK_SH|LOCK_NB)) < 0) {
  451.                 (void) close (f);
  452.                 if (errno == EWOULDBLOCK)
  453.                     goaway ("Collection %s is locked by another sup",collname);
  454.                 goaway ("Can't lock collection %s",collname);
  455.             }
  456.             vnotify ("SUP Waiting for exclusive access lock\n");
  457.             if (flock (f,LOCK_EX) < 0) {
  458.                 (void) close (f);
  459.                 goaway ("Can't lock collection %s",collname);
  460.             }
  461.         }
  462. #endif
  463.         thisC->Clockfd = f;
  464.         vnotify ("SUP Locked collection %s for exclusive access\n",collname);
  465.     }
  466.     logcrypt = (char *) NULL;
  467.     loguser = thisC->Clogin;
  468.     logpswd = thisC->Cpswd;
  469.  
  470. #ifndef    CRYPTING  /* Define CRYPTING for backwards compatibility with old supfileservers */
  471.     if (thisC->Clogin != (char *) NULL) /* othewise we only encrypt if there is a login id */
  472. #endif    /* CRYPTING */
  473.     {
  474.         logcrypt = CRYPTTEST;
  475.         (void) netcrypt (PSWDCRYPT);    /* encrypt password data */
  476.     }
  477.     x = msglogin ();
  478. #ifndef CRYPTING
  479.     if (thisC->Clogin != (char *) NULL) 
  480. #endif
  481.         (void) netcrypt ((char *)NULL);    /* turn off encryption */
  482.     if (x != SCMOK)
  483.         goaway ("Error sending login request to file server");
  484.     x = msglogack ();
  485.     if (x != SCMOK)
  486.         goaway ("Error reading login reply from file server");
  487.     if (logack == FLOGNG) {
  488.         notify ("SUP: %s\n",logerror);
  489.         free (logerror);
  490.         logerror = NULL;
  491.         notify ("SUP: Improper login to %s account",
  492.             thisC->Clogin ? thisC->Clogin : "default");
  493.         done (FDONESRVERROR,"Improper login");
  494.     }
  495.     if (netcrypt (thisC->Ccrypt) != SCMOK)    /* restore encryption */
  496.         goaway("Running non-crypting sup");
  497. }
  498.  
  499. /*
  500.  *  send list of files that we are not interested in.  receive list of
  501.  *  files that are on the repository that could be upgraded.  Find the
  502.  *  ones that we need.  Receive the list of files that the server could
  503.  *  not access.  Delete any files that have been upgraded in the past
  504.  *  which are no longer on the repository.
  505.  */
  506.  
  507. int listfiles ()
  508. {
  509.     int needone(), denyone(), deleteone();
  510.     char buf[STRINGLENGTH];
  511.     char relsufix[STRINGLENGTH];
  512.     register char *p,*q;
  513.     register FILE *f;
  514.     register int x;
  515.  
  516.  
  517.     if ((thisC->Cflags&CFURELSUF) && release)
  518.         (void) sprintf (relsufix,".%s",release);
  519.     else
  520.         relsufix[0] = '\0';
  521.     (void) sprintf (buf,FILELAST,collname,relsufix);
  522.     f = fopen (buf,"r");
  523.     if (f) {
  524.         while (p = fgets (buf,STRINGLENGTH,f)) {
  525.             if (q = index (p,'\n'))  *q = '\0';
  526.             if (index ("#;:",*p))  continue;
  527.             (void) Tinsert (&lastT,p,FALSE);
  528.         }
  529.         (void) fclose (f);
  530.     }
  531.     refuseT = NULL;
  532.     (void) sprintf (buf,FILEREFUSE,collname);
  533.     f = fopen (buf,"r");
  534.     if (f) {
  535.         while (p = fgets (buf,STRINGLENGTH,f)) {
  536.             if (q = index (p,'\n'))  *q = '\0';
  537.             if (index ("#;:",*p))  continue;
  538.             (void) Tinsert (&refuseT,p,FALSE);
  539.         }
  540.         (void) fclose (f);
  541.     }
  542.     vnotify ("SUP Requesting changes since %s",ctime (&lasttime) + 4);
  543.     x = msgrefuse ();
  544.     if (x != SCMOK)
  545.         goaway ("Error sending refuse list to file server");
  546.     listT = NULL;
  547.     x = msglist ();
  548.     if (x != SCMOK)
  549.         goaway ("Error reading file list from file server");
  550.     if (thisC->Cprefix)  (void) chdir (thisC->Cprefix);
  551.     needT = NULL;
  552.     (void) Tprocess (listT,needone);
  553.     Tfree (&listT);
  554.     x = msgneed ();
  555.     if (x != SCMOK)
  556.         goaway ("Error sending needed files list to file server");
  557.     Tfree (&needT);
  558.     denyT = NULL;
  559.     x = msgdeny ();
  560.     if (x != SCMOK)
  561.         goaway ("Error reading denied files list from file server");
  562.     if (thisC->Cflags&CFVERBOSE)
  563.         (void) Tprocess (denyT,denyone);
  564.     Tfree (&denyT);
  565.     if (thisC->Cflags&(CFALL|CFDELETE|CFOLD))
  566.         (void) Trprocess (lastT,deleteone);
  567.     Tfree (&refuseT);
  568. }
  569.  
  570. needone (t)
  571. register TREE *t;
  572. {
  573.     register TREE *newt;
  574.     register int exists, fetch;
  575.     struct stat sbuf;
  576.  
  577.     newt = Tinsert (&lastT,t->Tname,TRUE);
  578.     newt->Tflags |= FUPDATE;
  579.     fetch = TRUE;
  580.     if ((thisC->Cflags&CFALL) == 0) {
  581.         if ((t->Tflags&FNEW) == 0 && (thisC->Cflags&CFOLD) == 0)
  582.             return (SCMOK);
  583.         if ((t->Tmode&S_IFMT) == S_IFLNK)
  584.             exists = (lstat (t->Tname,&sbuf) == 0);
  585.         else
  586.             exists = (stat (t->Tname,&sbuf) == 0);
  587.         /* This is moderately complicated:
  588.            If the file is the wrong type or doesn't exist, we need to
  589.            fetch the whole file.  If the file is a special file, we
  590.            rely solely on the server:  if the file changed, we do an
  591.            update; otherwise nothing. If the file is a normal file,
  592.            we check timestamps.  If we are in "keep" mode, we fetch if
  593.            the file on the server is newer, and do nothing otherwise.
  594.            Otherwise, we fetch if the timestamp is wrong; if the file
  595.            changed on the server but the timestamp is right, we do an
  596.            update.  (Update refers to updating stat information, i.e.
  597.            timestamp, owner, mode bits, etc.) */
  598.         if (exists && (sbuf.st_mode&S_IFMT) == (t->Tmode&S_IFMT))
  599.             if ((t->Tmode&S_IFMT) != S_IFREG)
  600.                 if (t->Tflags&FNEW)
  601.                     fetch = FALSE;
  602.                 else return (SCMOK);
  603.             else if ((thisC->Cflags&CFKEEP) &&
  604.                  sbuf.st_mtime > t->Tmtime)
  605.                 return (SCMOK);
  606.             else if (sbuf.st_mtime == t->Tmtime)
  607.                 if (t->Tflags&FNEW)
  608.                     fetch = FALSE;
  609.                 else return (SCMOK);
  610.     }
  611.     /* If we get this far, we're either doing an update or a full fetch. */
  612.     newt = Tinsert (&needT,t->Tname,TRUE);
  613.     if (!fetch && (t->Tmode&S_IFMT) == S_IFREG)
  614.         newt->Tflags |= FUPDATE;
  615.     return (SCMOK);
  616. }
  617.  
  618. denyone (t)
  619. register TREE *t;
  620. {
  621.     vnotify ("SUP: Access denied to %s\n",t->Tname);
  622.     return (SCMOK);
  623. }
  624.  
  625. deleteone (t)
  626. TREE *t;
  627. {
  628.     struct stat sbuf;
  629.     register int x;
  630.     register char *name = t->Tname;
  631.  
  632.     if (t->Tflags&FUPDATE)        /* in current upgrade list */
  633.         return (SCMOK);
  634.     if (lstat(name,&sbuf) < 0)    /* doesn't exist */
  635.         return (SCMOK);
  636.     /* is it a symbolic link ? */
  637.     if ((sbuf.st_mode & S_IFMT) == S_IFLNK) {
  638.         if (Tlookup (refuseT,name)) {
  639.             vnotify ("SUP Would not delete symbolic link %s\n",
  640.                 name);
  641.             return (SCMOK);
  642.         }
  643.         if (thisC->Cflags&CFLIST) {
  644.             vnotify ("SUP Would delete symbolic link %s\n",name);
  645.             return (SCMOK);
  646.         }
  647.         if ((thisC->Cflags&CFDELETE) == 0) {
  648.             notify ("SUP Please delete symbolic link %s\n",name);
  649.             t->Tflags |= FUPDATE;
  650.             return (SCMOK);
  651.         }
  652.         x = unlink (name);
  653.         if (x < 0) {
  654.             notify ("SUP: Unable to delete symbolic link %s\n",
  655.                 name);
  656.             t->Tflags |= FUPDATE;
  657.             return (SCMOK);
  658.         }
  659.         vnotify ("SUP Deleted symbolic link %s\n",name);
  660.         return (SCMOK);
  661.     }
  662.     /* is it a directory ? */
  663.     if ((sbuf.st_mode & S_IFMT) == S_IFDIR) {
  664.         if (Tlookup (refuseT,name)) {
  665.             vnotify ("SUP Would not delete directory %s\n",name);
  666.             return (SCMOK);
  667.         }
  668.         if (thisC->Cflags&CFLIST) {
  669.             vnotify ("SUP Would delete directory %s\n",name);
  670.             return (SCMOK);
  671.         }
  672.         if ((thisC->Cflags&CFDELETE) == 0) {
  673.             notify ("SUP Please delete directory %s\n",name);
  674.             t->Tflags |= FUPDATE;
  675.             return (SCMOK);
  676.         }
  677.         (void) rmdir (name);
  678.         if (lstat(name,&sbuf) == 0) {
  679.             notify ("SUP: Unable to delete directory %s\n",name);
  680.             t->Tflags |= FUPDATE;
  681.             return (SCMOK);
  682.         }
  683.         vnotify ("SUP Deleted directory %s\n",name);
  684.         return (SCMOK);
  685.     }
  686.     /* it is a file */
  687.     if (Tlookup (refuseT,name)) {
  688.         vnotify ("SUP Would not delete file %s\n",name);
  689.         return (SCMOK);
  690.     }
  691.     if (thisC->Cflags&CFLIST) {
  692.         vnotify ("SUP Would delete file %s\n",name);
  693.         return (SCMOK);
  694.     }
  695.     if ((thisC->Cflags&CFDELETE) == 0) {
  696.         notify ("SUP Please delete file %s\n",name);
  697.         t->Tflags |= FUPDATE;
  698.         return (SCMOK);
  699.     }
  700.     x = unlink (name);
  701.     if (x < 0) {
  702.         notify ("SUP: Unable to delete file %s\n",name);
  703.         t->Tflags |= FUPDATE;
  704.         return (SCMOK);
  705.     }
  706.     vnotify ("SUP Deleted file %s\n",name);
  707.     return (SCMOK);
  708. }
  709.  
  710. /***************************************
  711.  ***    R E C E I V E   F I L E S    ***
  712.  ***************************************/
  713.  
  714. /* Note for these routines, return code SCMOK generally means
  715.  * NETWORK communication is OK; it does not mean that the current
  716.  * file was correctly received and stored.  If a file gets messed
  717.  * up, too bad, just print a message and go on to the next one;
  718.  * but if the network gets messed up, the whole sup program loses
  719.  * badly and best just stop the program as soon as possible.
  720.  */
  721.  
  722. recvfiles ()
  723. {
  724.     register int x;
  725.     int recvone ();
  726.     int recvmore;
  727.  
  728.     /* Does the protocol support compression */
  729.     if (cancompress) {
  730.         /* Check for compression on sending files */
  731.         docompress = (thisC->Cflags&CFCOMPRESS);
  732.         x = msgcompress();
  733.         if ( x != SCMOK) 
  734.             goaway ("Error sending compression check to server");
  735.         if (docompress)
  736.             vnotify("SUP Using compressed file transfer\n");
  737.     }
  738.     recvmore = TRUE;
  739.     upgradeT = NULL;
  740.     do {
  741.         x = msgsend ();
  742.         if (x != SCMOK)
  743.             goaway ("Error sending receive file request to file server");
  744.         (void) Tinsert (&upgradeT,(char *)NULL,FALSE);
  745.         x = msgrecv (recvone,&recvmore);
  746.         if (x != SCMOK)
  747.             goaway ("Error receiving file from file server");
  748.         Tfree (&upgradeT);
  749.     } while (recvmore);
  750. }
  751.  
  752. /* prepare the target, if necessary */
  753. prepare (name,mode,newp,statp)
  754. char *name;
  755. int mode,*newp;
  756. struct stat *statp;
  757. {
  758.     register char *type;
  759.  
  760.     if (mode == S_IFLNK)
  761.         *newp = (lstat (name,statp) < 0);
  762.     else
  763.         *newp = (stat (name,statp) < 0);
  764.     if (*newp) {
  765.         if (thisC->Cflags&CFLIST)
  766.             return (FALSE);
  767.         if (establishdir (name))
  768.             return (TRUE);
  769.         return (FALSE);
  770.     }
  771.     if (mode == (statp->st_mode&S_IFMT))
  772.         return (FALSE);
  773.     *newp = TRUE;
  774.     switch (statp->st_mode&S_IFMT) {
  775.     case S_IFDIR:
  776.         type = "directory";
  777.         break;
  778.     case S_IFLNK:
  779.         type = "symbolic link";
  780.         break;
  781.     case S_IFREG:
  782.         type = "regular file";
  783.         break;
  784.     default:
  785.         type = "unknown file";
  786.         break;
  787.     }
  788.     if (thisC->Cflags&CFLIST) {
  789.         vnotify ("SUP Would remove %s %s\n",type,name);
  790.         return (FALSE);
  791.     }
  792.     if ((statp->st_mode&S_IFMT) == S_IFDIR) {
  793.         if (rmdir (name) < 0)
  794.             runp ("rm","rm","-rf",name,0);
  795.     } else
  796.         (void) unlink (name);
  797.     if (stat (name,statp) < 0) {
  798.         vnotify ("SUP Removed %s %s\n",type,name);
  799.         return (FALSE);
  800.     }
  801.     notify ("SUP: Couldn't remove %s %s\n",type,name);
  802.     return (TRUE);
  803. }
  804.  
  805. recvone (t,ap)
  806. register TREE *t;
  807. va_list ap;
  808. {
  809.     register int x;
  810.     int new;
  811.     struct stat sbuf;
  812.     int linkone (),execone ();
  813.     int *recvmore = va_arg(ap,int *);
  814.  
  815.     /* check for end of file list */
  816.     if (t == NULL) {
  817.         *recvmore = FALSE;
  818.         return (SCMOK);
  819.     }
  820.     /* check for failed access at fileserver */
  821.     if (t->Tmode == 0) {
  822.         notify ("SUP: File server unable to transfer file %s\n",
  823.             t->Tname);
  824.         thisC->Cnogood = TRUE;
  825.         return (SCMOK);
  826.     }
  827.     if (prepare (t->Tname,t->Tmode&S_IFMT,&new,&sbuf)) {
  828.         notify ("SUP: Can't prepare path for %s\n",t->Tname);
  829.         if ((t->Tmode&S_IFMT) == S_IFREG) {
  830.             x = readskip ();    /* skip over file */
  831.             if (x != SCMOK)
  832.                 goaway ("Can't skip file transfer");
  833.         }
  834.         thisC->Cnogood = TRUE;
  835.         return (SCMOK);
  836.     }
  837.     /* make file mode specific changes */
  838.     switch (t->Tmode&S_IFMT) {
  839.     case S_IFDIR:
  840.         x = recvdir (t,new,&sbuf);
  841.         break;
  842.     case S_IFLNK:
  843.         x = recvsym (t,new,&sbuf);
  844.         break;
  845.     case S_IFREG:
  846.         x = recvreg (t,new,&sbuf);
  847.         break;
  848.     default:
  849.         goaway ("Unknown file type %o\n",t->Tmode&S_IFMT);
  850.     }
  851.     if (x) {
  852.         thisC->Cnogood = TRUE;
  853.         return (SCMOK);
  854.     }
  855.     if ((t->Tmode&S_IFMT) == S_IFREG)
  856.         (void) Tprocess (t->Tlink,linkone,t->Tname);
  857.     (void) Tprocess (t->Texec,execone);
  858.     return (SCMOK);
  859. }
  860.  
  861. int recvdir (t,new,statp)        /* receive directory from network */
  862. register TREE *t;
  863. register int new;
  864. register struct stat *statp;
  865. {
  866. #ifdef _ABI_SOURCE
  867.     struct utimbuf tbuf;
  868. #else
  869.     struct timeval tbuf[2];
  870. #endif
  871.  
  872.     if (new) {
  873.         if (thisC->Cflags&CFLIST) {
  874.             vnotify ("SUP Would create directory %s\n",t->Tname);
  875.             return (FALSE);
  876.         }
  877.         (void) mkdir (t->Tname,0755);
  878.         if (stat (t->Tname,statp) < 0) {
  879.             notify ("SUP: Can't create directory %s\n",t->Tname);
  880.             return (TRUE);
  881.         }
  882.     }
  883.     if ((t->Tflags&FNOACCT) == 0) {
  884.         /* convert user and group names to local ids */
  885.         ugconvert (t->Tuser,t->Tgroup,&t->Tuid,&t->Tgid,&t->Tmode);
  886.     }
  887.     if (!new && (t->Tflags&FNEW) == 0 && statp->st_mtime == t->Tmtime) {
  888.         if (t->Tflags&FNOACCT)
  889.             return (FALSE);
  890.         if (statp->st_uid == t->Tuid && statp->st_gid == t->Tgid)
  891.             return (FALSE);
  892.     }
  893.     if (thisC->Cflags&CFLIST) {
  894.         vnotify ("SUP Would update directory %s\n",t->Tname);
  895.         return (FALSE);
  896.     }
  897.     if ((t->Tflags&FNOACCT) == 0) {
  898.         (void) chown (t->Tname,t->Tuid,t->Tgid);
  899.         (void) chmod (t->Tname,t->Tmode&S_IMODE);
  900.     }
  901. #ifdef _ABI_SOURCE
  902.     tbuf.actime = time((long *)NULL);
  903.     tbuf.modtime = t->Tmtime;
  904.     (void) utime (t->Tname,&tbuf);
  905. #else
  906.     tbuf[0].tv_sec = time((long *)NULL);  tbuf[0].tv_usec = 0;
  907.     tbuf[1].tv_sec = t->Tmtime;  tbuf[1].tv_usec = 0;
  908.     (void) utimes (t->Tname,tbuf);
  909. #endif
  910.     vnotify ("SUP %s directory %s\n",new?"Created":"Updated",t->Tname);
  911.     return (FALSE);
  912. }
  913.  
  914. int recvsym (t,new,statp)            /* receive symbolic link */
  915. register TREE *t;
  916. register int new;
  917. register struct stat *statp;
  918. {
  919.     char buf[STRINGLENGTH];
  920.     int n;
  921.     register char *linkname;
  922.  
  923.     if (t->Tlink == NULL || t->Tlink->Tname == NULL) {
  924.         notify ("SUP: Missing linkname for symbolic link %s\n",
  925.             t->Tname);
  926.         return (TRUE);
  927.     }
  928.     linkname = t->Tlink->Tname;
  929.     if (!new && (t->Tflags&FNEW) == 0 &&
  930.         (n = readlink (t->Tname,buf,sizeof(buf))) >= 0 &&
  931.         (n == strlen (linkname)) && (strncmp (linkname,buf,n) == 0))
  932.         return (FALSE);
  933.     if (thisC->Cflags&CFLIST) {
  934.         vnotify ("SUP Would %s symbolic link %s to %s\n",
  935.             new?"create":"update",t->Tname,linkname);
  936.         return (FALSE);
  937.     }
  938.     if (!new)
  939.         (void) unlink (t->Tname);
  940.     if (symlink (linkname,t->Tname) < 0 || lstat(t->Tname,statp) < 0) {
  941.         notify ("SUP: Unable to create symbolic link %s\n",t->Tname);
  942.         return (TRUE);
  943.     }
  944.     vnotify ("SUP Created symbolic link %s to %s\n",t->Tname,linkname);
  945.     return (FALSE);
  946. }
  947.  
  948. int recvreg (t,new,statp)            /* receive file from network */
  949. register TREE *t;
  950. register int new;
  951. register struct stat *statp;
  952. {
  953.     register FILE *fin,*fout;
  954.     char dirpart[STRINGLENGTH],filepart[STRINGLENGTH];
  955.     char filename[STRINGLENGTH],buf[STRINGLENGTH];
  956. #ifdef _ABI_SOURCE
  957.     struct utimbuf tbuf;
  958. #else
  959.     struct timeval tbuf[2];
  960. #endif
  961.     register int x;
  962.     register char *p;
  963.  
  964.     if (t->Tflags&FUPDATE) {
  965.         if ((t->Tflags&FNOACCT) == 0) {
  966.             /* convert user and group names to local ids */
  967.             ugconvert (t->Tuser,t->Tgroup,&t->Tuid,&t->Tgid,
  968.                 &t->Tmode);
  969.         }
  970.         if (!new && (t->Tflags&FNEW) == 0 &&
  971.             statp->st_mtime == t->Tmtime) {
  972.             if (t->Tflags&FNOACCT)
  973.                 return (FALSE);
  974.             if (statp->st_uid == t->Tuid &&
  975.                 statp->st_gid == t->Tgid)
  976.                 return (FALSE);
  977.         }
  978.         if (thisC->Cflags&CFLIST) {
  979.             vnotify ("SUP Would update file %s\n",t->Tname);
  980.             return (FALSE);
  981.         }
  982.         vnotify ("SUP Updating file %s\n",t->Tname);
  983.         if ((t->Tflags&FNOACCT) == 0) {
  984.             (void) chown (t->Tname,t->Tuid,t->Tgid);
  985.             (void) chmod (t->Tname,t->Tmode&S_IMODE);
  986.         }
  987. #ifdef _ABI_SOURCE
  988.         tbuf.actime = time((long *)NULL);
  989.         tbuf.modtime = t->Tmtime;
  990.         (void) utime (t->Tname,&tbuf);
  991. #else
  992.         tbuf[0].tv_sec = time((long *)NULL);  tbuf[0].tv_usec = 0;
  993.         tbuf[1].tv_sec = t->Tmtime;  tbuf[1].tv_usec = 0;
  994.         (void) utimes (t->Tname,tbuf);
  995. #endif
  996.         return (FALSE);
  997.     }
  998.     if (thisC->Cflags&CFLIST) {
  999.         if (new)
  1000.             p = "create";
  1001.         else if (statp->st_mtime < t->Tmtime)
  1002.             p = "receive new";
  1003.         else if (statp->st_mtime > t->Tmtime)
  1004.             p = "receive old";
  1005.         else
  1006.             p = "receive";
  1007.         vnotify ("SUP Would %s file %s\n",p,t->Tname);
  1008.         return (FALSE);
  1009.     }
  1010.     vnotify ("SUP Receiving file %s\n",t->Tname);
  1011.     if (!new && (t->Tmode&S_IFMT) == S_IFREG &&
  1012.         (t->Tflags&FBACKUP) && (thisC->Cflags&CFBACKUP)) {
  1013.         fin = fopen (t->Tname,"r");    /* create backup */
  1014.         if (fin == NULL) {
  1015.             x = readskip ();    /* skip over file */
  1016.             if (x != SCMOK)
  1017.                 goaway ("Can't skip file transfer");
  1018.             notify ("SUP: Can't open %s to create backup\n",
  1019.                 t->Tname);
  1020.             return (TRUE);        /* mark upgrade as nogood */
  1021.         }
  1022.         path (t->Tname,dirpart,filepart);
  1023.         (void) sprintf (filename,FILEBACKUP,dirpart,filepart);
  1024.         fout = fopen (filename,"w");
  1025.         if (fout == NULL) {
  1026.             (void) sprintf (buf,FILEBKDIR,dirpart);
  1027.             (void) mkdir (buf,0755);
  1028.             fout = fopen (filename,"w");
  1029.         }
  1030.         if (fout == NULL) {
  1031.             x = readskip ();    /* skip over file */
  1032.             if (x != SCMOK)
  1033.                 goaway ("Can't skip file transfer");
  1034.             notify ("SUP: Can't create %s for backup\n",filename);
  1035.             (void) fclose (fin);
  1036.             return (TRUE);
  1037.         }
  1038.         ffilecopy (fin,fout);
  1039.         (void) fclose (fin);
  1040.         (void) fclose (fout);
  1041.         vnotify ("SUP Backup of %s created\n", t->Tname);
  1042.     }
  1043.     x = copyfile (t->Tname,(char *)NULL);
  1044.     if (x)
  1045.         return (TRUE);
  1046.     if ((t->Tflags&FNOACCT) == 0) {
  1047.         /* convert user and group names to local ids */
  1048.         ugconvert (t->Tuser,t->Tgroup,&t->Tuid,&t->Tgid,&t->Tmode);
  1049.         (void) chown (t->Tname,t->Tuid,t->Tgid);
  1050.         (void) chmod (t->Tname,t->Tmode&S_IMODE);
  1051.     }
  1052. #ifdef _ABI_SOURCE
  1053.     tbuf.actime = time((long *)NULL);
  1054.     tbuf.modtime = t->Tmtime;
  1055.     (void) utime (t->Tname,&tbuf);
  1056. #else
  1057.     tbuf[0].tv_sec = time((long *)NULL);  tbuf[0].tv_usec = 0;
  1058.     tbuf[1].tv_sec = t->Tmtime;  tbuf[1].tv_usec = 0;
  1059.     (void) utimes (t->Tname,tbuf);
  1060. #endif
  1061.     return (FALSE);
  1062. }
  1063.  
  1064. linkone (t,fname)            /* link to file already received */
  1065. register TREE *t;
  1066. register char **fname;
  1067. {
  1068.     struct stat fbuf,sbuf;
  1069.     register char *name = t->Tname;
  1070.     int new,x;
  1071.     char *type;
  1072.  
  1073.     if (stat(*fname,&fbuf) < 0) {    /* source file */
  1074.         if (thisC->Cflags&CFLIST) {
  1075.             vnotify ("SUP Would link %s to %s\n",name,*fname);
  1076.             return (SCMOK);
  1077.         }
  1078.         notify ("SUP: Can't link %s to missing file %s\n",name,*fname);
  1079.         thisC->Cnogood = TRUE;
  1080.         return (SCMOK);
  1081.     }
  1082.     if (prepare (name,S_IFREG,&new,&sbuf)) {
  1083.         notify ("SUP: Can't prepare path for link %s\n",name);
  1084.         thisC->Cnogood = TRUE;
  1085.         return (SCMOK);
  1086.     }
  1087.     if (!new && (t->Tflags&FNEW) == 0 &&
  1088.         fbuf.st_dev == sbuf.st_dev && fbuf.st_ino == sbuf.st_ino)
  1089.         return (SCMOK);
  1090.     if (thisC->Cflags&CFLIST) {
  1091.         vnotify ("SUP Would link %s to %s\n",name,*fname);
  1092.         return (SCMOK);
  1093.     }
  1094.     (void) unlink (name);
  1095.     type = "";
  1096.     if ((x = link (*fname,name)) < 0) {
  1097.         type = "symbolic ";
  1098.         x = symlink (*fname,name);
  1099.     }
  1100.     if (x < 0 || lstat(name,&sbuf) < 0) {
  1101.         notify ("SUP: Unable to create %slink %s\n",type,name);
  1102.         return (TRUE);
  1103.     }
  1104.     vnotify ("SUP Created %slink %s to %s\n",type,name,*fname);
  1105.     return (SCMOK);
  1106. }
  1107.  
  1108. execone (t)            /* execute command for file */
  1109. register TREE *t;
  1110. {
  1111.     union wait w;
  1112.  
  1113.     if (thisC->Cflags&CFLIST) {
  1114.         vnotify ("SUP Would execute %s\n",t->Tname);
  1115.         return (SCMOK);
  1116.     }
  1117.     if ((thisC->Cflags&CFEXECUTE) == 0) {
  1118.         notify ("SUP Please execute %s\n",t->Tname);
  1119.         return (SCMOK);
  1120.     }
  1121.     vnotify ("SUP Executing %s\n",t->Tname);
  1122.  
  1123.     w.w_status = system (t->Tname);
  1124.     if (WIFEXITED(w) && w.w_retcode != 0) {
  1125.         notify ("SUP: Execute command returned failure status %#o\n",
  1126.             w.w_retcode);
  1127.         thisC->Cnogood = TRUE;
  1128.     } else if (WIFSIGNALED(w)) {
  1129.         notify ("SUP: Execute command killed by signal %d\n",
  1130.             w.w_termsig);
  1131.         thisC->Cnogood = TRUE;
  1132.     } else if (WIFSTOPPED(w)) {
  1133.         notify ("SUP: Execute command stopped by signal %d\n",
  1134.             w.w_stopsig);
  1135.         thisC->Cnogood = TRUE;
  1136.     }
  1137.     return (SCMOK);
  1138. }
  1139.  
  1140. int copyfile (to,from)
  1141. char *to;
  1142. char *from;        /* 0 if reading from network */
  1143. {
  1144.     register int fromf,tof,istemp,x;
  1145.     char dpart[STRINGLENGTH],fpart[STRINGLENGTH];
  1146.     char tname[STRINGLENGTH];
  1147.     char sys_com[STRINGLENGTH];
  1148.     struct stat sbuf;
  1149.  
  1150.     static int thispid = 0;        /* process id # */
  1151.  
  1152.     if (from) {            /* reading file */
  1153.         fromf = open (from,O_RDONLY,0);
  1154.         if (fromf < 0) {
  1155.             notify ("SUP: Can't open %s to copy to %s: %s\n",
  1156.                 from,to,errmsg (-1));
  1157.             return (TRUE);
  1158.         }
  1159.     } else                /* reading network */
  1160.         fromf = -1;
  1161.     istemp = TRUE;            /* try to create temp file */
  1162.     lockout (TRUE);            /* block interrupts */
  1163.     if (thispid == 0)  thispid = getpid ();
  1164.     /* Now try hard to find a temp file name.  Try VERY hard. */
  1165.     for (;;) {
  1166.     /* try destination directory */
  1167.         path (to,dpart,fpart);
  1168.         (void) sprintf (tname,"%s/#%d.sup",dpart,thispid);
  1169.         tof = open (tname,(O_WRONLY|O_CREAT|O_TRUNC),0600);
  1170.         if (tof >= 0)  break;
  1171.     /* try sup directory */
  1172.         if (thisC->Cprefix)  (void) chdir (thisC->Cbase);
  1173.         (void) sprintf (tname,"sup/#%d.sup",thispid);
  1174.         tof = open (tname,(O_WRONLY|O_CREAT|O_TRUNC),0600);
  1175.         if (tof >= 0) {
  1176.             if (thisC->Cprefix)  (void) chdir (thisC->Cprefix);
  1177.             break;
  1178.         }
  1179.     /* try base directory */
  1180.         (void) sprintf (tname,"#%d.sup",thispid);
  1181.         tof = open (tname,(O_WRONLY|O_CREAT|O_TRUNC),0600);
  1182.         if (thisC->Cprefix)  (void) chdir (thisC->Cprefix);
  1183.         if (tof >= 0)  break;
  1184. #ifdef    VAR_TMP
  1185.     /* try /var/tmp */
  1186.         (void) sprintf (tname,"/var/tmp/#%d.sup",thispid);
  1187.         tof = open (tname,(O_WRONLY|O_CREAT|O_TRUNC),0600);
  1188.         if (tof >= 0)  break;
  1189. #else
  1190.     /* try /usr/tmp */
  1191.         (void) sprintf (tname,"/usr/tmp/#%d.sup",thispid);
  1192.         tof = open (tname,(O_WRONLY|O_CREAT|O_TRUNC),0600);
  1193.         if (tof >= 0)  break;
  1194. #endif
  1195.     /* try /tmp */
  1196.         (void) sprintf (tname,"/tmp/#%d.sup",thispid);
  1197.         tof = open (tname,(O_WRONLY|O_CREAT|O_TRUNC),0600);
  1198.         if (tof >= 0)  break;
  1199.         istemp = FALSE;
  1200.     /* give up: try to create output file */
  1201.         if (!docompress)
  1202.             tof = open (to,(O_WRONLY|O_CREAT|O_TRUNC),0600);
  1203.         if (tof >= 0)  break;
  1204.     /* no luck */
  1205.         notify ("SUP: Can't create %s or temp file for it\n",to);
  1206.         lockout (FALSE);
  1207.         if (fromf >= 0)
  1208.             (void) close (fromf);
  1209.         else {
  1210.             x = readskip ();
  1211.             if (x != SCMOK)
  1212.                 goaway ("Can't skip file transfer");
  1213.         }
  1214.         return (TRUE);
  1215.     }
  1216.     if (fromf >= 0) {        /* read file */
  1217.         x = filecopy (fromf,tof);
  1218.         (void) close (fromf);
  1219.         (void) close (tof);
  1220.         if (x < 0) {
  1221.             notify ("SUP: Error in copying %s to %s\n",from,to);
  1222.             if (istemp)  (void) unlink (tname);
  1223.             lockout (FALSE);
  1224.             return (TRUE);
  1225.         }
  1226.     } else {            /* read network */
  1227. #if    MACH
  1228.         if (!rpauseflag) {
  1229.             int fsize;
  1230.             struct fsparam fsp;
  1231.  
  1232.             x = prereadcount (&fsize);
  1233.             if (x != SCMOK) {
  1234.                 if (istemp)  (void) unlink (tname);
  1235.                 lockout (FALSE);
  1236.                 x = readskip ();
  1237.                 if (x != SCMOK)
  1238.                     goaway ("Can't skip file transfer");
  1239.                 goaway ("Error in server space check");
  1240.                 logquit (1,"Error in server space check");
  1241.             }
  1242.             errno = 0;
  1243.             if (ioctl (tof,FIOCFSPARAM,(char *)&fsp) < 0 &&
  1244.                 errno != EINVAL) {
  1245.                 if (istemp)  (void) unlink (tname);
  1246.                 lockout (FALSE);
  1247.                 x = readskip ();
  1248.                 if (x != SCMOK)
  1249.                     goaway ("Can't skip file transfer");
  1250.                 goaway ("Error in disk space check");
  1251.                 logquit (1,"Error in disk space check");
  1252.             }
  1253.             if (errno == 0) {
  1254.                 fsize = (fsize + 1023) / 1024;
  1255.                 x = fsp.fsp_size * MAX (fsp.fsp_minfree,1) / 100;
  1256.                 fsp.fsp_free -= x;
  1257.                 if (fsize > MAX (fsp.fsp_free,0)) {
  1258.                     if (istemp)  (void) unlink (tname);
  1259.                     lockout (FALSE);
  1260.                     x = readskip ();
  1261.                     if (x != SCMOK)
  1262.                         goaway ("Can't skip file transfer");
  1263.                     goaway ("No disk space for file %s", to);
  1264.                     logquit (1,"No disk space for file %s",to);
  1265.                 }
  1266.             }
  1267.         }
  1268. #endif    /* MACH */
  1269.         x = readfile (tof);
  1270.         (void) close (tof);
  1271.         if (x != SCMOK) {
  1272.             if (istemp)  (void) unlink (tname);
  1273.             lockout (FALSE);
  1274.             goaway ("Error in receiving %s\n",to);
  1275.         }
  1276.     }
  1277.     if (!istemp) {            /* no temp file used */
  1278.         lockout (FALSE);
  1279.         return (FALSE);
  1280.     }
  1281.     /* uncompress it first */
  1282.     if (docompress) {
  1283.         sprintf(sys_com, "gunzip < %s > %s\n", tname, to);
  1284.         /* Uncompress it onto the destination */
  1285.         if (system(sys_com) < 0) {
  1286.             notify ("SUP: Error in uncompressing file %s\n",
  1287.                 to);
  1288.             (void) unlink (tname);
  1289.             /* Just in case */
  1290.             (void) unlink (to);
  1291.             lockout (FALSE);
  1292.             return (TRUE);
  1293.         }
  1294.         (void) unlink (tname);
  1295.         lockout (FALSE);
  1296.         return (FALSE);
  1297.     }
  1298.     /* move to destination */
  1299.     if (rename (tname,to) == 0) {
  1300.         (void) unlink (tname);
  1301.         lockout (FALSE);
  1302.         return (FALSE);
  1303.     }
  1304.     fromf = open (tname,O_RDONLY,0);
  1305.     if (fromf < 0) {
  1306.         notify ("SUP: Error in moving temp file to %s: %s\n",
  1307.             to,errmsg (-1));
  1308.         (void) unlink (tname);
  1309.         lockout (FALSE);
  1310.         return (TRUE);
  1311.     }
  1312.     tof = open (to,(O_WRONLY|O_CREAT|O_TRUNC),0600);
  1313.     if (tof < 0) {
  1314.         (void) close (fromf);
  1315.         notify ("SUP: Can't create %s from temp file: %s\n",
  1316.             to,errmsg (-1));
  1317.         (void) unlink (tname);
  1318.         lockout (FALSE);
  1319.         return (TRUE);
  1320.     }
  1321.     x = filecopy (fromf,tof);
  1322.     (void) close (fromf);
  1323.     (void) close (tof);
  1324.     (void) unlink (tname);
  1325.     lockout (FALSE);
  1326.     if (x < 0) {
  1327.         notify ("SUP: Error in storing data in %s\n",to);
  1328.         return (TRUE);
  1329.     }
  1330.     return (FALSE);
  1331. }
  1332.  
  1333. /***  Finish connection with file server ***/
  1334.  
  1335. finishup (x)
  1336. int x;
  1337. {
  1338.     char tname[STRINGLENGTH],fname[STRINGLENGTH];
  1339.     char relsufix[STRINGLENGTH];
  1340.     char collrelname[STRINGLENGTH];
  1341.     long tloc;
  1342.     FILE *finishfile;        /* record of all filenames */
  1343.     int f,finishone();
  1344.  
  1345.     if ((thisC->Cflags&CFURELSUF) && release) {
  1346.         (void) sprintf (relsufix,".%s",release);
  1347.         (void) sprintf (collrelname,"%s-%s",collname,release);
  1348.     } else {
  1349.         relsufix[0] = '\0';
  1350.         (void) strcpy (collrelname,collname);
  1351.     }
  1352.     dontjump = TRUE;        /* once here, no more longjmp */
  1353.     (void) netcrypt ((char *)NULL);
  1354.     if (protver < 6) {
  1355.         /* done with server */
  1356.         if (x == SCMOK)
  1357.             goaway ((char *)NULL);
  1358.         (void) requestend ();
  1359.     }
  1360.     tloc = time ((long *)NULL);
  1361.     if (x != SCMOK) {
  1362.         notify ("SUP: Upgrade of %s aborted at %s",
  1363.             collrelname,ctime (&tloc) + 4);
  1364.         Tfree (&lastT);
  1365.         if (protver < 6)  return;
  1366.         /* if we've not been blown off, make sure he is! */
  1367.         if (x != SCMEOF)
  1368.             goaway ("Aborted");
  1369.         (void) requestend ();
  1370.         return;
  1371.     }
  1372.     if (thisC->Cnogood) {
  1373.         notify ("SUP: Upgrade of %s completed with errors at %s",
  1374.             collrelname,ctime (&tloc) + 4);
  1375.         notify ("SUP: Upgrade time will not be updated\n");
  1376.         Tfree (&lastT);
  1377.         if (protver < 6)  return;
  1378.         done (FDONEUSRERROR,"Completed with errors");
  1379.         (void) requestend ();
  1380.         return;
  1381.     }
  1382.     if (thisC->Cprefix)  (void) chdir (thisC->Cbase);
  1383.     vnotify ("SUP Upgrade of %s completed at %s",
  1384.          collrelname,ctime (&tloc) + 4);
  1385.     if (thisC->Cflags&CFLIST) {
  1386.         Tfree (&lastT);
  1387.         if (protver < 6)  return;
  1388.         done (FDONEDONTLOG,"List only");
  1389.         (void) requestend ();
  1390.         return;
  1391.     }
  1392.     (void) sprintf (fname,FILEWHEN,collname,relsufix);
  1393.     if (establishdir (fname)) {
  1394.         notify ("SUP: Can't create directory for upgrade timestamp\n");
  1395.         Tfree (&lastT);
  1396.         if (protver < 6)  return;
  1397.         done (FDONEUSRERROR,"Couldn't timestamp");
  1398.         (void) requestend ();
  1399.         return;
  1400.     }
  1401.     f = open (fname,(O_WRONLY|O_CREAT|O_TRUNC),0644);
  1402.     if (f < 0) {
  1403.         notify ("SUP: Can't record current time in %s: %s\n",
  1404.             fname,errmsg (-1));
  1405.         Tfree (&lastT);
  1406.         if (protver < 6)  return;
  1407.         done (FDONEUSRERROR,"Couldn't timestamp");
  1408.         (void) requestend ();
  1409.         return;
  1410.     }
  1411.     (void) write (f,(char *)&scantime,sizeof(int));
  1412.     (void) close (f);
  1413.     if (protver >= 6) {
  1414.         /* At this point we have let the server go */
  1415.         /* "I'm sorry, we've had to let you go" */
  1416.         done (FDONESUCCESS,"Success");
  1417.         (void) requestend ();
  1418.     }
  1419.     (void) sprintf (tname,FILELASTTEMP,collname);
  1420.     finishfile = fopen (tname,"w");
  1421.     if (finishfile == NULL) {
  1422.         notify ("SUP: Can't record list of all files in %s\n",tname);
  1423.         Tfree (&lastT);
  1424.         return;
  1425.     }
  1426.     (void) Tprocess (lastT,finishone,finishfile);
  1427.     (void) fclose (finishfile);
  1428.     (void) sprintf (fname,FILELAST,collname,relsufix);
  1429.     if (rename (tname,fname) < 0)
  1430.         notify ("SUP: Can't change %s to %s\n",tname,fname);
  1431.     (void) unlink (tname);
  1432.     Tfree (&lastT);
  1433. }
  1434.  
  1435. finishone (t,finishfile)
  1436. TREE *t;
  1437. FILE **finishfile;
  1438. {
  1439.     if ((thisC->Cflags&CFDELETE) == 0 || (t->Tflags&FUPDATE))
  1440.         fprintf (*finishfile,"%s\n",t->Tname);
  1441.     return (SCMOK);
  1442. }
  1443.  
  1444. #if __STDC__
  1445. void
  1446. done (int value,char *fmt,...)
  1447. #else
  1448. /*VARARGS*//*ARGSUSED*/
  1449. done (va_alist)
  1450. va_dcl
  1451. #endif
  1452. {
  1453. #if !__STDC__
  1454.     int value;
  1455.     char *fmt;
  1456. #endif
  1457.     char buf[STRINGLENGTH];
  1458.     va_list ap;
  1459.  
  1460.     (void) netcrypt ((char *)NULL);
  1461. #if __STDC__
  1462.     va_start(ap,fmt);
  1463. #else
  1464.     va_start(ap);
  1465.     value = va_arg(ap,int);
  1466.     fmt = va_arg(ap,char *);
  1467. #endif
  1468.     if (fmt) 
  1469.         vsnprintf(buf, sizeof(buf), fmt, ap);
  1470.     va_end(ap);
  1471.     if (protver < 6) {
  1472.         if (goawayreason)
  1473.             free (goawayreason);
  1474.         goawayreason = (fmt) ? salloc (buf) : (char *)NULL;
  1475.         (void) msggoaway ();
  1476.     }
  1477.     else {
  1478.         doneack = value;
  1479.         donereason = (fmt) ? buf : (char *)NULL;
  1480.         (void) msgdone ();
  1481.     }
  1482.     if (!dontjump)
  1483.         longjmp (sjbuf,TRUE);
  1484. }
  1485. #if __STDC__
  1486. void
  1487. goaway (char *fmt,...)
  1488. #else
  1489. /*VARARGS*//*ARGSUSED*/
  1490. goaway (va_alist)
  1491. va_dcl
  1492. #endif
  1493. {
  1494. #if !__STDC__
  1495.     register char *fmt;
  1496. #endif
  1497.     char buf[STRINGLENGTH];
  1498.     va_list ap;
  1499.  
  1500.     (void) netcrypt ((char *)NULL);
  1501. #if __STDC__
  1502.     va_start(ap,fmt);
  1503. #else
  1504.     va_start(ap);
  1505.     fmt = va_arg(ap,char *);
  1506. #endif
  1507.     if (fmt) {
  1508.         vsnprintf(buf, sizeof(buf), fmt, ap);
  1509.         goawayreason = buf;
  1510.     } else
  1511.         goawayreason = NULL;
  1512.     va_end(ap);
  1513.     (void) msggoaway ();
  1514.     if (fmt)
  1515.         if (thisC)
  1516.             notify ("SUP: %s\n",buf);
  1517.         else
  1518.             printf ("SUP: %s\n",buf);
  1519.     if (!dontjump)
  1520.         longjmp (sjbuf,TRUE);
  1521. }
  1522.